home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d13 / pproject.arc / NETWORK.CLS < prev    next >
Encoding:
Text File  |  1990-06-07  |  4.6 KB  |  186 lines
  1. /* The Network class is a formal class which defines basic
  2.    connection methods for nodes. The network maintains the
  3.    start and end nodes as well as two dictionaries of nodes.
  4.    NodeNames uses the name as key, display uses the relative
  5.    position as key for easy window "hit testing" etc. */!!
  6.  
  7. inherit(Object, #Network, #(name       /* network name */
  8. desc       /* longer description */
  9. start      /* starting node */
  10. end        /* ending node */
  11. nodeNames  /* dictionary by name */
  12. display    /* dictionary by posn */), 2, nil)!!
  13.  
  14. now(NetworkClass)!!
  15.  
  16. /* Create a new network. */
  17. Def  new(self)
  18. { 
  19.   ^init(new(self:Behavior));
  20. }  !!    
  21.  
  22. now(Network)!!
  23.  
  24. /* Return the node if the name exists in the
  25.    nodeNames dictionary, otherwise return false and
  26.    display an error message. */
  27. Def  checkNodeExists(self, nodeName | node)
  28. {
  29.   if not(node := nodeExists(self, nodeName))
  30.     beep();
  31.     errorBox(loadString(PW_NODEINVAL), 
  32.       nodeName + loadString(PW_NOTEXIST));
  33.   endif;
  34.   ^node;
  35. }!!
  36.  
  37. /* Adjust the display as necessary.
  38.    Called by setPosn, resetPosn in class Node. */
  39. Def  resetPosn(self, aNode, oldPos)
  40. {    
  41.   if (oldPos in display) = aNode
  42.     remove(display, oldPos);
  43.   endif;
  44.   
  45.   /* if there is a conflict adjust as necessary */
  46.   /* the resulting diagram may not be perfect */
  47.   
  48.   if pos(aNode) in display      /* conflict */
  49.     if aNode.y > 0              /* not top row */
  50.       aNode.y := aNode.y - 1;   /* go up */
  51.     endif;
  52.     loop 
  53.     while pos(aNode) in display
  54.       aNode.y := aNode.y + 1;   /* go down */
  55.     endLoop;
  56.   endif;
  57.    
  58.   add(display, pos(aNode), aNode);
  59. }!!
  60.  
  61. /* Return the number of nodes in the network. */
  62. Def  size(self)
  63. {
  64.   ^size(nodeNames);
  65. }!!
  66.  
  67. /* Given a point position, lookup the node. */
  68. Def  displayLookup(self, pos)
  69. { 
  70.   ^display[pos];
  71. }!!
  72.  
  73. /* Return a dictionary of nodes. */
  74. Def  nodes(self)
  75. {
  76.   ^nodeNames;
  77. }!!
  78.  
  79. /* Return the type of nodes that start and end should be.
  80.    Descendants will redefine this method. */
  81. Def  nodeClass(self)
  82. {
  83.   ^Node;
  84. }!!
  85.  
  86. /* Remove a node from the node table. */
  87. Def  removeNode(self, aNode)
  88. { 
  89.   remove(nodeNames, getName(aNode));
  90. }!!
  91.  
  92. /* Add a node to the node table.  Use it's name as the key. */
  93. Def  addNode(self, aNode)
  94. { 
  95.   add(nodeNames, getName(aNode), aNode);
  96. }!!
  97.  
  98. /* Check if the nodes name1 and name2 exist.  If so,
  99.    disconnect node1->node2.  */
  100. Def  disconnect(self, name1, name2 | node1, node2)
  101. {
  102.   node1 := checkNodeExists(self, name1);
  103.   node2 := checkNodeExists(self, name2);
  104.   if node1 cand node2
  105.     disconnect(node1, node2);
  106.   endif;
  107. }!!
  108.  
  109. /* Return the node if the name exists in the
  110.    nodeNames dictionary, otherwise return false.
  111.    If error checking is required, use checkNodeExists. */
  112. Def  nodeExists(self, nodeName | node)
  113. {
  114.   ^nodeName in nodeNames;
  115. }!!
  116.  
  117. /* Check if the nodes name1 and name2 exist.  If so,
  118.    connect node1->node2.  */
  119. Def  connect(self, name1, name2 | node1, node2)
  120. {
  121.   node1 := checkNodeExists(self, name1);
  122.   node2 := checkNodeExists(self, name2);
  123.   if node1 cand node2
  124.     connect(node1, node2);
  125.   endif;
  126. }!!
  127.  
  128. /* Get the description. */
  129. Def  getDesc(self)
  130. { ^desc;
  131. } !!
  132.  
  133. /* Show a diagram of the network.  Keep track
  134.    of visited nodes to avoid looping. 
  135.    Note: Only for use during development. */
  136. Def  show(self | visited)
  137. { 
  138.   printLine("");
  139.   printLine(self);            /* title */
  140.   CurPos:=0;                  /* global variable */
  141.   visited := new(Set,10);
  142.   add(visited,start); 
  143.   show(start, visited, 0);    /* begin recursing */
  144.   printLine("");
  145. }!!
  146.  
  147. /* Set the name. */
  148. Def  setName(self, aName)
  149. { name := aName;
  150. }  !! 
  151.  
  152. /* Get the name. */
  153. Def  getName(self)
  154. { ^name;
  155. } !!
  156.  
  157. /* Initialize a new Network. Create the start and end nodes
  158.    and add them to the dictionaries.  The dictionaries will
  159.    grow in size as necessary.  Uses the nodeClass method
  160.    to determine what type of nodes start and end should be.  */
  161. Def  init(self)
  162. { name := "";
  163.   desc := "";
  164.   start := new(nodeClass(self));
  165.   setName(start,"Start");
  166.   end := new(nodeClass(self));
  167.   setName(end,"End");
  168.   end.x := 0; end.y := 1;    /* default location */
  169.   start.network := end.network := self;
  170.   
  171.   nodeNames := new(Dictionary, 10);     /* by name */
  172.   nodeNames["Start"] := start;
  173.   nodeNames["End"] := end;
  174.   
  175.   display := new(Dictionary, 10);       /* by posn */
  176.   add(display, pos(start), start);
  177.   add(display, pos(end), end);
  178. } !! 
  179.  
  180. /* print the network name */
  181. Def  printOn(self, aStream)
  182. { printOn(asString(class(self)) + "(" + name + ")",
  183.   aStream);
  184. } !!
  185.  
  186.